This still doesn't achieve what we want. I've just finished modifying our templates to use swiftIdentifier:"pretty" instead of swiftIdentifier|snakeToCamelCase, but we didn't account for these cases:

• Cyan-Color --> Cyan_Color instead of CyanColor
• .SFNSDisplay --> _SFNSDisplay instead of SFNSDisplay
• .SFNSDisplay --> _SFNSDisplay instead of SFNSDisplay
• Accept-CGU --> Accept_CGU instead of AcceptCGU
• Show-NavCtrl --> Show_NavCtrl instead of ShowNavCtrl
• apples.count --> Apples_Count instead of ApplesCount
• multiLine\nKey --> MultiLine_Key instead of MultiLineKey

Replacing the current "pretty" implementation from:
replace:" "|snakeToCamelCase:"true"|swiftIdentifier
with:
swiftIdentifier|snakeToCamelCase:"true"|swiftIdentifier
solves all the issues mentioned above.

@AliSoftware I know you didn't want to run the filter twice, how would you suggest solving these issues?

Replace not only spaces but also dashes and periods with underscore before snakeToCamelCase? Or more generally using a RegEx and use the word separator character class to split the string first?

Right, replace - and .. But what about \n? (see multiline key) Should the user expect those to be replaced too? Or other characters?

We could also use string.enumerateSubstringsInRange(range, options: NSStringEnumerationOptions.ByWords)

Right, replace - and .. But what about \n? (see multiline key) Should the user expect those to be replaced too? Or other characters?

That's why I mentioned the more generic answer of using some official unicode word separator 😉

I have to admit I don't know what that matches (words, sure, but how?). Going to read some docs 😄

Or CFStringTokenizer and kCFStringTokenizerUnitWord.
Or NSLinguisticTagger

(whatever is compatible with Linux would be preferable)

Quick Playground test:

import Foundation

extension String {
  func words() -> [String] {

    let range = self.startIndex..<self.endIndex
    var words = [String]()

    self.enumerateSubstrings(in: range, options: .byWords) { (substring, _, _, _) -> () in
      words.append(substring!)
    }

    return words
  }

  func upFirst() -> String {
    guard let first = self.characters.first else { return self }
    return String(first).uppercased() + String(self.characters.dropFirst())
  }
}

extension Array where Element == String {
  func camelJoin() -> String {
    return self.map { $0.upFirst() }.joined(separator: "")
  }
}


print("Cyan-Color".words().camelJoin())
print(".SFNSDisplay".words().camelJoin())
print("Accept-CGU".words().camelJoin())
print("Show-NavCtrl".words().camelJoin())
print("apples.count".words().camelJoin())
print("apples. count".words().camelJoin())
print("multiLine\nKey".words().camelJoin())

Gives:

CyanColor
SFNSDisplay
AcceptCGU
ShowNavCtrl
Apples.count
MultiLineKey

We could argue in considering x.y as 2 words too to make that ApplesCount instead of having Apples.count (that will become Apples_count once swiftIdentifier'd) but the rest seems consistent

If I use that addition:

  func punctWords() -> [String] {
    return self.components(separatedBy: .punctuationCharacters).flatMap({ $0.words() })
  }

Then we got:

"apples.count".punctWords().camelJoin()
// ApplesCount
"a_b.c.d-e_f".punctWords().camelJoin()
// ABCDEF
"foo_bar.baz.qux-yay".punctWords().camelJoin()
// FooBarBazQuxYay

After all from a logical standpoint, that's exactly what we want: having a string that is CamelCased, that is upper case at… word boundaries. Be that boundaries be an underscore, a dash, a period, or similar. After all that's how we CamelCase strings in our head, right?

You know what? Even string.components(separatedBy: NSCharacterSet.alphanumerics.inverted).camelJoin() could be sufficient actually, it seems

func test(strings: [String], apply: (String) -> String) {
  for s in strings {
    let orig = s.replacingOccurrences(of: "\n", with: "\\n").padding(toLength: 20, withPad: " ", startingAt: 0)
    let res = apply(s)
    print("\(orig) --> \(res)")
  }
}

let inputs = ["Cyan-Color", ".SFNSDisplay", "Accept-CGU", "Show-NavCtrl", "apples.count", "apples. count", "multiLine\nKey","foo_bar.baz.qux-yay"]

test(strings: inputs) {
  $0.components(separatedBy: NSCharacterSet.alphanumerics.inverted).camelJoin()
}
/*
Cyan-Color           --> CyanColor
.SFNSDisplay         --> SFNSDisplay
Accept-CGU           --> AcceptCGU
Show-NavCtrl         --> ShowNavCtrl
apples.count         --> ApplesCount
apples. count        --> ApplesCount
multiLine\nKey       --> MultiLineKey
foo_bar.baz.qux-yay  --> FooBarBazQuxYay
*/

Ok, continuing the thought, maybe the logical thing to do would be to split using any character that is invalid as a swift identifier character indeed, instead of splitting using any character that is not an alphanumeric. So that we keep any emoji or whatnot untouched.

But then guess what… that would be equivalent of "splitting the string using non-swift-char boundaries, then capitalising the first char of each "word" found, then joining"… which would actually be equivalent of swiftIdentifier|camelCase|swiftIdentifier in the end… so maybe you were right all along and I just needed to convince myself… 😇

That then breaks things for strings such as HEADER_TITLE --> HEADERTITLE, and other issues with full uppercase keys.

This works though:

		string = string
			.components(separatedBy: NSCharacterSet.alphanumerics.inverted)
			.joined(separator: "_")
		string = try snakeToCamelCase(string, stripLeading: true)
		return StencilSwiftKit.swiftIdentifier(from: string, replaceWithUnderscores: true)

Oh, you beat me to it, indeed, emoji 🤷‍♂️

What we could do, is:

• swiftidentifier
• snakeToCamelCase:"true"
• titlecase
• prefix with _ if needed

So, move the last 2 items from swiftidentifier into a loose function that we can call separately.

Actually, ignore that titlecase after the snake filter, it isn't needed.

Ah, looks like a good idea! 👍